const app = getApp()
const api = require('../../utils/request')

Page({
  /**
   * 页面的初始数据
   * userInfo: 用户基本信息对象
   * healthInfo: 用户健康信息对象
   * medicalHistory: 用户病史信息对象
   * riskLevels: 风险等级选项数组
   * diabetesTypes: 糖尿病类型选项数组
   * activityLevels: 体力活动水平选项
   * activityLevelIndex: 当前选择的体力活动水平索引
   * physiologicalStatuses: 生理状况选项
   * physiologicalStatusIndex: 当前选择的生理状况索引
   */
  data: {
    userInfo: {},
    healthInfo: {
      height: '',      // 身高(cm)
      weight: '',      // 体重(kg)
      bmi: '',         // BMI值
      waistline: '',   // 腰围(cm)
      bloodType: '',   // 血型
      diabetesType: 0, // 糖尿病类型: 0-无, 1-1型, 2-2型, 3-妊娠, 4-其他
      diagnosisYear: '', // 确诊年份
      riskLevel: 0     // 风险等级: 0-低风险, 1-中风险, 2-高风险
    },
    medicalHistory: {
      hasDiabetes: false,       // 是否患有糖尿病
      hasHypertension: false,   // 是否患有高血压
      hasHeartDisease: false,   // 是否患有心脏病
      hasKidneyDisease: false,  // 是否患有肾病
      familyDiabetes: false,    // 家族是否有糖尿病史
      medications: []           // 当前服用的药物列表
    },
    bloodTypes: ['A型', 'B型', 'AB型', 'O型'],
    diabetesTypes: ['无', '1型糖尿病', '2型糖尿病', '妊娠糖尿病', '其他类型'],
    riskLevels: ['低风险', '中风险', '高风险'],
    // 体力活动水平选项
    activityLevels: ['轻度(Ⅰ)', '中度(Ⅱ)', '重度(Ⅲ)'],
    activityLevelIndex: 0,
    // 生理状况选项
    physiologicalStatuses: ['普通', '孕早期(1-12周)', '孕中期(13-27周)', '孕晚期(28周以上)', '哺乳期'],
    physiologicalStatusIndex: 0,
    years: [],  // 年份选择器数据
    isNewUser: false, // 是否为新用户
    needSaveReminder: false, // 是否需要提醒保存
    isEditing: false, // 是否处于编辑模式
    originalData: {}, // 保存原始数据，用于取消时恢复
    currentDate: '', // 当前日期，用于日期选择器限制
    nutritionTarget: {
      calories: 2200,
      carbs: 275,
      protein: 110,
      fat: 73
    }
  },

  /**
   * 生命周期函数--监听页面加载
   * 初始化用户信息和生成年份选项
   */
  onLoad(options) {
    // 从全局数据或本地存储获取用户信息
    let userInfo = app.globalData.userInfo || wx.getStorageSync('userInfo') || {}
    
    // 生成年份选择器数据，从1950年到当前年份
    const currentYear = new Date().getFullYear()
    const years = []
    for (let i = currentYear; i >= 1950; i--) {
      years.push(i.toString())
    }
    
    // 设置页面数据
    this.setData({ 
      userInfo,
      years,
      isNewUser: !userInfo.nickName && !userInfo.nickname, // 如果没有昵称，视为新用户
      isEditing: options.edit === 'true' || (!userInfo.nickName && !userInfo.nickname), // 如果是从编辑入口或新用户，直接进入编辑模式
      currentDate: new Date().toISOString().split('T')[0] // 设置当前日期
    })
    
    // 重要：必须先获取最新的用户信息
    this.fetchUserInfo()
    
    // 监听表单变化，提示保存
    this.watchFormChanges()
    
    // 监听返回按钮
    this.handleBackButton()
  },
  
  /**
   * 处理返回按钮事件
   */
  handleBackButton() {
    // 微信小程序API中，使用页面的onUnload事件和自定义的返回处理函数
    // 而不是wx.onBackPress（这在某些版本不可用）
    this.setData({
      hasSetBackHandler: true // 标记已设置返回处理器
    });
  },
  
  /**
   * 用户点击左上角返回按钮或使用物理返回键时触发
   */
  onBeforeBack() {
    // 如果有未保存的修改
    if (this.data.needSaveReminder) {
      wx.showModal({
        title: '提示',
        content: '您有未保存的修改，是否保存？',
        confirmText: '保存',
        cancelText: '放弃修改',
        success: (res) => {
          if (res.confirm) {
            // 用户选择保存
            this.saveUserInfo();
          } else {
            // 用户选择放弃修改，直接返回
            wx.navigateBack();
          }
        }
      });
      return true; // 阻止默认返回行为
    }
    return false; // 不阻止默认返回行为
  },
  
  /**
   * 监听返回事件
   */
  onBack() {
    return this.onBeforeBack();
  },
  
  /**
   * 获取用户信息
   */
  async fetchUserInfo() {
    try {
      const userProfileRes = await api.getUserProfile()
      if (userProfileRes.success && userProfileRes.data) {
        const userData = userProfileRes.data
        
        // 处理从后端获取的性别数据
        let gender = userData.gender
        if (gender === '男') {
          gender = 1
        } else if (gender === '女') {
          gender = 2
        } else {
          gender = null // 未设置状态
        }
        
        // 计算年龄（如果有出生日期但没有年龄）
        let age = userData.age || ''
        if (!age && userData.birthDate) {
          age = this.calculateAge(userData.birthDate)
        }
        
        // 设置用户基本信息
        this.setData({
          userInfo: {
            ...this.data.userInfo,
            // 确保使用正确的字段名
            nickName: userData.nickname || userData.nickName || this.data.userInfo.nickName || '',
            nickname: userData.nickname || userData.nickName || this.data.userInfo.nickname || '',
            gender: gender,
            age: age,
            birthDate: userData.birthDate ? userData.birthDate.substring(0, 10) : '',
            avatarUrl: userData.avatarUrl || this.data.userInfo.avatarUrl || '',
            phoneNumber: userData.phoneNumber || '',
            email: userData.email || ''
          }
        })
        
        console.log('获取到的用户资料:', userData)
        console.log('设置的用户信息:', this.data.userInfo)
        
        // 在获取用户基本信息后，获取健康信息和病史信息
        await this.fetchHealthInfo()
        await this.fetchMedicalHistory()
      }
    } catch (err) {
      console.error('获取用户信息失败:', err)
    }
  },
  
  /**
   * 监听所有表单变化，如有修改则提示用户保存
   */
  watchFormChanges() {
    // 使用setData的回调监视数据变化
    const originalSetData = this.setData
    this.setData = (obj, callback) => {
      // 调用原始setData
      originalSetData.call(this, obj, () => {
        // 如果修改了关键数据且不是初始加载，则标记需要保存
        if (obj.userInfo || obj.healthInfo || obj.medicalHistory) {
          if (!this.data.isInitialLoad) {
            this.setData({
              needSaveReminder: true
            }, () => {})
          }
        }
        // 执行原始回调
        callback && callback()
      })
    }
    
    // 初始加载完成后设置标记
    setTimeout(() => {
      this.data.isInitialLoad = false
    }, 1000)
  },
  
  /**
   * 获取用户健康信息
   */
  async fetchHealthInfo() {
    try {
      // 直接从用户profile获取健康信息
      const userProfileRes = await api.getUserProfile();
      if (userProfileRes.success && userProfileRes.data) {
        const userData = userProfileRes.data;
        
        // 调试日志：输出原始用户数据中的血型
        console.log('==================== fetchHealthInfo 调试信息 ====================')
        console.log('原始用户数据:', userData);
        console.log('原始用户数据中的血型:', userData.bloodType);
        console.log('原始用户数据中的生理状况:', userData.physiologicalStatus);
        console.log('原始用户数据中的体力活动水平:', userData.activityLevel);
        
        // 处理用户出生日期和年龄 - 现在在fetchUserInfo中处理，这里不再需要
        
        const healthInfo = {
          height: userData.height || '',
          weight: userData.weight || '',
          waistline: userData.waistline || '',
          bloodType: userData.bloodType || '',
          diabetesType: userData.diabetesType ? this.getDiabetesTypeValue(userData.diabetesType) : 0,
          diagnosisYear: userData.diagnosisDate ? new Date(userData.diagnosisDate).getFullYear().toString() : ''
        };
        
        // 处理体力活动水平
        let activityLevelIndex = 0;
        if (userData.activityLevel) {
          switch (userData.activityLevel) {
            case 'light':
              activityLevelIndex = 0;
              break;
            case 'moderate':
              activityLevelIndex = 1;
              break;
            case 'heavy':
              activityLevelIndex = 2;
              break;
          }
        }
        
        // 处理生理状况
        let physiologicalStatusIndex = 0;
        if (userData.physiologicalStatus) {
          switch (userData.physiologicalStatus) {
            case 'normal':
              physiologicalStatusIndex = 0;
              break;
            case 'pregnant_early':
              physiologicalStatusIndex = 1;
              break;
            case 'pregnant_mid':
              physiologicalStatusIndex = 2;
              break;
            case 'pregnant_late':
              physiologicalStatusIndex = 3;
              break;
            case 'breastfeeding':
              physiologicalStatusIndex = 4;
              break;
          }
        }
        
        // 调试日志：输出处理后的健康信息中的血型
        console.log('处理后的健康信息:', healthInfo);
        console.log('处理后的健康信息中的血型:', healthInfo.bloodType);
        console.log('处理后的活动水平索引:', activityLevelIndex);
        console.log('处理后的生理状况索引:', physiologicalStatusIndex);
        console.log('==================== fetchHealthInfo 调试信息结束 ====================')
        
        // 计算BMI
        if (healthInfo.height && healthInfo.weight) {
          const heightM = healthInfo.height / 100;
          const bmi = (healthInfo.weight / (heightM * heightM)).toFixed(1);
          healthInfo.bmi = bmi;
        }
        
        this.setData({ 
          healthInfo,
          activityLevelIndex,
          physiologicalStatusIndex
        });
        
        // 加载营养目标信息
        this.updateNutritionTargets(userData.nutritionTarget);
      }
    } catch (err) {
      console.error('获取健康信息失败:', err);
    }
  },
  
  /**
   * 更新营养目标信息
   */
  updateNutritionTargets(nutritionTarget) {
    if (nutritionTarget) {
      console.log('更新营养目标:', nutritionTarget);
      this.setData({
        nutritionTarget: {
          calories: nutritionTarget.calories || 2200,
          carbs: nutritionTarget.carbs || 275,
          protein: nutritionTarget.protein || 110,
          fat: nutritionTarget.fat || 73
        }
      });
    }
  },
  
  /**
   * 获取用户病史信息
   */
  async fetchMedicalHistory() {
    try {
      // 直接从用户profile获取病史信息
      const userProfileRes = await api.getUserProfile();
      if (userProfileRes.success && userProfileRes.data) {
        const userData = userProfileRes.data;
        const medicalHistory = {
          hasDiabetes: userData.diabetesType && userData.diabetesType !== '无',
          hasHypertension: userData.hasHypertension || false,
          hasHeartDisease: userData.hasHeartDisease || false,
          hasKidneyDisease: userData.hasKidneyDisease || false,
          familyDiabetes: userData.familyDiabetes || false,
          medications: userData.medications || []
        };
        
        this.setData({ medicalHistory });
      }
    } catch (err) {
      console.error('获取病史信息失败:', err);
    }
  },

  /**
   * 将糖尿病类型字符串转换为数值
   */
  getDiabetesTypeValue(typeString) {
    switch (typeString) {
      case '1型': return 1;
      case '2型': return 2;
      case '妊娠期': return 3;
      case '其他': return 4;
      default: return 0;
    }
  },

  /**
   * 更换头像
   * 调用系统相册或相机API选择新头像
   */
  changeAvatar() {
    wx.chooseImage({
      count: 1,
      sizeType: ['compressed'], // 压缩图片以节省空间
      sourceType: ['album', 'camera'], // 允许从相册或相机选择
      success: (res) => {
        const tempFilePath = res.tempFilePaths[0]
        this.setData({
          'userInfo.avatarUrl': tempFilePath
        })
      }
    })
  },

  /**
   * 昵称变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onNicknameChange(e) {
    this.setData({
      'userInfo.nickName': e.detail.value,
      'userInfo.nickname': e.detail.value // 同时更新nickname字段
    })
  },

  /**
   * 性别变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onGenderChange(e) {
    const gender = parseInt(e.detail.value);
    
    // 更新userInfo中的性别
    this.setData({
      'userInfo.gender': gender
    });
    
    // 如果是男性，自动设置生理状况为"普通"且不允许修改
    if (gender === 1) { // 1表示男性
      this.setData({
        physiologicalStatusIndex: 0 // 0表示"普通"
      });
    }
  },

  /**
   * 生理状况变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onPhysiologicalStatusChange(e) {
    // 如果是男性，不允许更改生理状况
    if (this.data.userInfo.gender === 1) {
      return;
    }
    
    const index = parseInt(e.detail.value);
    this.setData({
      physiologicalStatusIndex: index
    });
  },
  
  /**
   * 体力活动水平变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onActivityLevelChange(e) {
    const index = parseInt(e.detail.value);
    this.setData({
      activityLevelIndex: index
    });
  },

  /**
   * 出生日期变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onBirthDateChange(e) {
    const birthDate = e.detail.value
    // 保存出生日期
    this.setData({
      'userInfo.birthDate': birthDate
    })
    
    // 计算年龄
    if (birthDate) {
      const age = this.calculateAge(birthDate)
      this.setData({
        'userInfo.age': age
      })
    }
  },
  
  /**
   * 根据出生日期计算年龄
   * @param {String} birthDateStr - 出生日期字符串
   * @returns {Number} 计算得到的年龄
   */
  calculateAge(birthDateStr) {
    const today = new Date()
    const birthDate = new Date(birthDateStr)
    let age = today.getFullYear() - birthDate.getFullYear()
    const monthDiff = today.getMonth() - birthDate.getMonth()
    
    // 如果今年还没到生日，年龄减1
    if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
      age--
    }
    
    return age
  },

  /**
   * 身高变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onHeightChange(e) {
    const height = e.detail.value
    
    // 验证输入是否为数字
    if (height && !/^\d+$/.test(height)) {
      wx.showToast({
        title: '请输入有效数字',
        icon: 'none'
      })
      return
    }
    
    // 验证身高范围
    if (height && (Number(height) < 50 || Number(height) > 250)) {
      wx.showToast({
        title: '身高应在50-250cm之间',
        icon: 'none'
      })
      return
    }
    
    let bmi = ''
    
    // 如果身高和体重都存在，计算BMI
    if (height && this.data.healthInfo.weight) {
      const heightM = height / 100
      bmi = (this.data.healthInfo.weight / (heightM * heightM)).toFixed(1)
    }
    
    this.setData({
      'healthInfo.height': height,
      'healthInfo.bmi': bmi
    })
  },
  
  /**
   * 体重变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onWeightChange(e) {
    const weight = e.detail.value
    
    // 验证输入是否为数字
    if (weight && !/^\d+(\.\d+)?$/.test(weight)) {
      wx.showToast({
        title: '请输入有效数字',
        icon: 'none'
      })
      return
    }
    
    // 验证体重范围
    if (weight && (Number(weight) < 20 || Number(weight) > 300)) {
      wx.showToast({
        title: '体重应在20-300kg之间',
        icon: 'none'
      })
      return
    }
    
    let bmi = ''
    
    // 如果身高和体重都存在，计算BMI
    if (this.data.healthInfo.height && weight) {
      const heightM = this.data.healthInfo.height / 100
      bmi = (weight / (heightM * heightM)).toFixed(1)
    }
    
    this.setData({
      'healthInfo.weight': weight,
      'healthInfo.bmi': bmi
    })
  },
  
  /**
   * 血型变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onBloodTypeChange(e) {
    const index = e.detail.value
    const bloodType = this.data.bloodTypes[index]
    
    // 调试日志：输出血型选择信息
    console.log('==================== onBloodTypeChange 调试信息 ====================')
    console.log('选择的血型索引:', index)
    console.log('血型数组:', this.data.bloodTypes)
    console.log('选择的血型:', bloodType)
    
    this.setData({
      'healthInfo.bloodType': bloodType
    })
    
    // 调试日志：确认设置后的血型
    console.log('设置后的血型:', this.data.healthInfo.bloodType)
    console.log('==================== onBloodTypeChange 调试信息结束 ====================')
  },
  
  /**
   * 糖尿病类型变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onDiabetesTypeChange(e) {
    const diabetesType = parseInt(e.detail.value)
    
    // 如果选择无糖尿病，则清空确诊年份
    if (diabetesType === 0) {
      this.setData({
        'healthInfo.diabetesType': diabetesType,
        'healthInfo.diagnosisYear': ''
      })
    } else {
      this.setData({
        'healthInfo.diabetesType': diabetesType
      })
    }
  },
  
  /**
   * 确诊年份变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onDiagnosisYearChange(e) {
    const index = e.detail.value
    this.setData({
      'healthInfo.diagnosisYear': this.data.years[index]
    })
  },
  
  /**
   * 风险等级变化处理函数
   * @param {Object} e - 选择事件对象
   */
  onRiskLevelChange(e) {
    this.setData({
      'healthInfo.riskLevel': parseInt(e.detail.value)
    })
  },
  
  /**
   * 病史变化处理函数，处理所有开关类选项
   * @param {Object} e - 开关事件对象
   */
  onMedicalHistoryChange(e) {
    const field = e.currentTarget.dataset.field
    const value = e.detail.value
    
    if (field) {
      // 动态构建key，如'medicalHistory.hasHypertension'
      const key = `medicalHistory.${field}`
      let data = {}
      data[key] = value
      
      // 如果字段是hasDiabetes，并且值为false，则同时重置糖尿病类型为0
      if (field === 'hasDiabetes' && !value) {
        data['healthInfo.diabetesType'] = 0
        data['healthInfo.diagnosisYear'] = ''
      }
      
      this.setData(data)
    }
  },
  
  /**
   * 自动计算风险等级
   * 基于填写的健康信息评估用户的健康风险等级
   */
  autoAssessRisk() {
    // 获取当前数据
    const { userInfo, healthInfo, medicalHistory } = this.data
    let riskScore = 0 // 风险分数
    
    // 基于年龄评分
    if (userInfo.age) {
      const age = parseInt(userInfo.age)
      if (age > 65) {
        riskScore += 2 // 高龄，高风险
      } else if (age > 45) {
        riskScore += 1 // 中年，中风险
      }
    }
    
    // 基于BMI评分
    if (healthInfo.bmi) {
      const bmi = parseFloat(healthInfo.bmi)
      if (bmi >= 28) {
        riskScore += 2 // 肥胖，高风险
      } else if (bmi >= 24) {
        riskScore += 1 // 超重，中风险
      }
    }
    
    // 基于病史评分
    if (medicalHistory.hasHypertension) riskScore += 1 // 高血压
    if (medicalHistory.hasHeartDisease) riskScore += 2 // 心脏病
    if (medicalHistory.hasKidneyDisease) riskScore += 1 // 肾病
    if (medicalHistory.familyDiabetes) riskScore += 1 // 家族史
    
    // 确定风险等级
    let riskLevel = 0
    if (riskScore >= 4) {
      riskLevel = 2 // 高风险
    } else if (riskScore >= 2) {
      riskLevel = 1 // 中风险
    }
    
    // 更新风险等级
    this.setData({
      'healthInfo.riskLevel': riskLevel
    })
    
    // 显示评估结果提示
    wx.showToast({
      title: `风险评估结果：${this.data.riskLevels[riskLevel]}`,
      icon: 'none',
      duration: 2000
    })
  },

  /**
   * 开始编辑状态
   * 保存原始数据，以便取消编辑时恢复
   */
  startEditing() {
    // 深拷贝当前数据以便恢复
    const originalData = {
      userInfo: JSON.parse(JSON.stringify(this.data.userInfo)),
      healthInfo: JSON.parse(JSON.stringify(this.data.healthInfo)),
      medicalHistory: JSON.parse(JSON.stringify(this.data.medicalHistory))
    }
    
    this.setData({
      isEditing: true,
      originalData
    })
  },

  /**
   * 取消编辑，恢复原始数据
   */
  cancelEdit() {
    // 如果是新用户，返回上一页
    if (this.data.isNewUser) {
      wx.navigateBack({
        delta: 1
      })
      return
    }
    
    // 恢复原始数据
    this.restoreOriginalData()
    
    this.setData({
      isEditing: false,
      needSaveReminder: false
    })
  },

  /**
   * 恢复原始数据
   */
  restoreOriginalData() {
    const { originalData } = this.data
    if (!originalData.userInfo) return
    
    // 单独设置每个属性，保证响应式更新
    // 用户信息
    this.setData({
      'userInfo.nickName': originalData.userInfo.nickName,
      'userInfo.gender': originalData.userInfo.gender,
      'userInfo.age': originalData.userInfo.age,
      'userInfo.avatarUrl': originalData.userInfo.avatarUrl,
      'userInfo.phoneNumber': originalData.userInfo.phoneNumber,
      'userInfo.email': originalData.userInfo.email
    })
    
    // 健康信息
    this.setData({
      'healthInfo.height': originalData.healthInfo.height,
      'healthInfo.weight': originalData.healthInfo.weight,
      'healthInfo.bmi': originalData.healthInfo.bmi,
      'healthInfo.waistline': originalData.healthInfo.waistline,
      'healthInfo.bloodType': originalData.healthInfo.bloodType,
      'healthInfo.diabetesType': originalData.healthInfo.diabetesType,
      'healthInfo.diagnosisYear': originalData.healthInfo.diagnosisYear,
      'healthInfo.riskLevel': originalData.healthInfo.riskLevel
    })
    
    // 病史信息
    this.setData({
      'medicalHistory.hasDiabetes': originalData.medicalHistory.hasDiabetes,
      'medicalHistory.hasHypertension': originalData.medicalHistory.hasHypertension,
      'medicalHistory.hasHeartDisease': originalData.medicalHistory.hasHeartDisease,
      'medicalHistory.hasKidneyDisease': originalData.medicalHistory.hasKidneyDisease,
      'medicalHistory.familyDiabetes': originalData.medicalHistory.familyDiabetes
    })
  },

  /**
   * 数据验证函数
   * @param {Object} userInfo - 用户基本信息对象
   * @param {Object} healthInfo - 用户健康信息对象
   * @returns {string|null} - 验证错误信息或null（验证通过）
   */
  validateUserData(userInfo, healthInfo) {
    console.log('开始验证用户数据:', { userInfo, healthInfo });
    
    // 昵称验证
    if (!userInfo.nickName && !userInfo.nickname) {
      console.log('验证失败: 昵称为空');
      wx.showToast({
        title: '请输入昵称',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 性别验证
    if (![1, 2].includes(userInfo.gender)) {
      console.log('验证失败: 性别无效', userInfo.gender);
      wx.showToast({
        title: '请选择有效的性别',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 出生日期验证
    if (!userInfo.birthDate) {
      console.log('验证失败: 出生日期为空');
      wx.showToast({
        title: '请选择出生日期',
        icon: 'none',
        duration: 2000
      });
      return false;
    } else {
      const birthDate = new Date(userInfo.birthDate);
      const today = new Date();
      const minDate = new Date(1900, 0, 1); // 最小出生日期：1900年1月1日
      
      if (birthDate > today) {
        console.log('验证失败: 出生日期超过今天', userInfo.birthDate);
        wx.showToast({
          title: '出生日期不能超过今天',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
      
      if (birthDate < minDate) {
        console.log('验证失败: 出生日期早于1900年', userInfo.birthDate);
        wx.showToast({
          title: '出生日期不能早于1900年',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
      
      // 计算年龄，不允许超过150岁
      const age = this.calculateAge(userInfo.birthDate);
      if (age > 150) {
        console.log('验证失败: 年龄超过150岁', age);
        wx.showToast({
          title: '年龄不能超过150岁',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    }
    
    // 邮箱验证
    if (userInfo.email && !this.validateEmail(userInfo.email)) {
      console.log('验证失败: 邮箱格式无效', userInfo.email);
      wx.showToast({
        title: '请输入有效的邮箱地址',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 电话号码验证
    if (userInfo.phoneNumber && !this.validatePhoneNumber(userInfo.phoneNumber)) {
      console.log('验证失败: 电话号码格式无效', userInfo.phoneNumber);
      wx.showToast({
        title: '请输入有效的手机号码',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 身高验证
    if (healthInfo.height) {
      const height = Number(healthInfo.height);
      if (!Number.isFinite(parseFloat(healthInfo.height))) {
        console.log('验证失败: 身高不是数字', healthInfo.height);
        wx.showToast({
          title: '身高必须是数字',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
      if (height < 50 || height > 250) {
        console.log('验证失败: 身高超出范围', height);
        wx.showToast({
          title: '请输入有效的身高(50-250cm)',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    } else {
      console.log('验证失败: 身高为空');
      wx.showToast({
        title: '请输入身高',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 验证体重
    if (healthInfo.weight) {
      const weight = Number(healthInfo.weight);
      if (!Number.isFinite(parseFloat(healthInfo.weight))) {
        console.log('验证失败: 体重不是数字', healthInfo.weight);
        wx.showToast({
          title: '体重必须是数字',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
      if (weight < 20 || weight > 300) {
        console.log('验证失败: 体重超出范围', weight);
        wx.showToast({
          title: '请输入有效的体重(20-300kg)',
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    } else {
      console.log('验证失败: 体重为空');
      wx.showToast({
        title: '请输入体重',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 血型验证(可选)
    if (healthInfo.bloodType && !['A型', 'B型', 'AB型', 'O型'].includes(healthInfo.bloodType)) {
      console.log('验证失败: 血型无效', healthInfo.bloodType);
      wx.showToast({
        title: '请选择有效的血型',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 糖尿病类型验证
    if (healthInfo.diabetesType !== 0 && healthInfo.diabetesType > 4) {
      console.log('验证失败: 糖尿病类型无效', healthInfo.diabetesType);
      wx.showToast({
        title: '请选择有效的糖尿病类型',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
    
    // 诊断年份验证
    if (healthInfo.diabetesType > 0 && healthInfo.diagnosisYear) {
      const year = Number(healthInfo.diagnosisYear);
      const currentYear = new Date().getFullYear();
      if (isNaN(year) || year < 1900 || year > currentYear) {
        console.log('验证失败: 确诊年份无效', healthInfo.diagnosisYear);
        wx.showToast({
          title: `请选择有效的确诊年份(1900-${currentYear})`,
          icon: 'none',
          duration: 2000
        });
        return false;
      }
    }
    
    console.log('验证通过!');
    return true; // 验证通过
  },

  /**
   * 验证邮箱格式
   * @param {string} email - 邮箱地址
   * @returns {boolean} - 是否是有效的邮箱格式
   */
  validateEmail(email) {
    // 如果邮箱为空，视为有效（允许不设置邮箱）
    if (!email) return true;
    
    // 邮箱格式的正则表达式
    const emailRegex = /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/;
    return emailRegex.test(email);
  },

  /**
   * 邮箱变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onEmailChange(e) {
    const email = e.detail.value;
    this.setData({
      'userInfo.email': email
    });
    
    // 如果邮箱不为空且格式不正确，提示用户
    if (email && !this.validateEmail(email)) {
      wx.showToast({
        title: '邮箱格式不正确',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 验证手机号格式
   * @param {string} phoneNumber - 手机号码
   * @returns {boolean} - 是否是有效的手机号格式
   */
  validatePhoneNumber(phoneNumber) {
    // 如果手机号为空，视为有效（允许不设置手机号）
    if (!phoneNumber) return true;
    
    // 中国大陆手机号格式的正则表达式
    const phoneRegex = /^1[3-9]\d{9}$/;
    return phoneRegex.test(phoneNumber);
  },

  /**
   * 电话号码变化处理函数
   * @param {Object} e - 输入事件对象
   */
  onPhoneNumberChange(e) {
    const phoneNumber = e.detail.value;
    this.setData({
      'userInfo.phoneNumber': phoneNumber
    });
    
    // 如果手机号不为空且格式不正确，提示用户
    if (phoneNumber && !this.validatePhoneNumber(phoneNumber)) {
      wx.showToast({
        title: '手机号格式不正确',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 直接API测试
   * @param {string} url - API URL
   * @param {string} method - HTTP方法
   * @param {Object} data - 请求数据
   * @returns {Promise} - API响应
   */
  directApiTest(url, method, data) {
    console.log(`[直接API测试] ${method} ${url}`, data);
    
    // 获取Token
    const token = wx.getStorageSync('token') || '';
    
    return new Promise((resolve, reject) => {
      wx.request({
        url: `http://127.0.0.1:5002/api${url}`,
        method,
        data,
        header: {
          'Content-Type': 'application/json',
          'x-auth-token': token
        },
        success: (res) => {
          console.log(`[直接API测试] 响应:`, res);
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(res.data);
          } else {
            reject(res.data || new Error('API请求失败'));
          }
        },
        fail: (err) => {
          console.error(`[直接API测试] 错误:`, err);
          reject(err);
        }
      });
    });
  },

  /**
   * 保存用户信息
   * 将表单数据提交到后端API
   */
  async saveUserInfo() {
    console.log('点击保存按钮');
    wx.showLoading({
      title: '验证中...',
      mask: true
    });
    
    // 表单验证
    if (!this.validateUserData(this.data.userInfo, this.data.healthInfo)) {
      wx.hideLoading();
      return;
    }
    
    wx.showLoading({
      title: '保存中...',
      mask: true
    });
    
    console.log('开始保存用户信息:', this.data.userInfo);
    console.log('开始保存健康信息:', this.data.healthInfo);
    console.log('开始保存病史信息:', this.data.medicalHistory);
    
    try {
      // 获取用户ID
      const userId = this.data.userInfo._id;
      if (!userId) {
        console.error('保存失败：找不到用户ID');
        wx.showToast({
          title: '保存失败：找不到用户ID',
          icon: 'none'
        });
        wx.hideLoading();
        return;
      }
      
      // 获取bmi值
      const bmi = this.data.healthInfo.bmi;
      
      // 准备生理状况和活动水平的字符串值
      const physiologicalStatus = this.getPhysiologicalStatusString();
      const activityLevel = this.getActivityLevelString();
      const diabetesType = this.getDiabetesTypeString();
      
      console.log('生理状况：', physiologicalStatus);
      console.log('活动水平：', activityLevel);
      console.log('糖尿病类型：', diabetesType);
      
      // 准备各种健康指标，确保数据类型正确
      const height = this.data.healthInfo.height ? parseFloat(this.data.healthInfo.height) : '';
      const weight = this.data.healthInfo.weight ? parseFloat(this.data.healthInfo.weight) : '';
      const waistline = this.data.healthInfo.waistline ? parseFloat(this.data.healthInfo.waistline) : '';
      const bloodType = this.data.healthInfo.bloodType || '';
      
      // 准备用户健康档案数据 - 展开所有字段
      const healthProfileData = {
        _id: userId,
        userId: userId,
        gender: this.data.userInfo.gender === 1 ? '男' : '女',
        birthDate: this.data.userInfo.birthDate,
        height: height,
        weight: weight,
        waistline: waistline,
        bmi: bmi || '',
        bloodType: bloodType,
        diabetesType: diabetesType,
        // 展开医疗历史，而不是作为嵌套对象
        hasDiabetes: this.data.medicalHistory.hasDiabetes,
        hasHypertension: this.data.medicalHistory.hasHypertension,
        hasHeartDisease: this.data.medicalHistory.hasHeartDisease,
        hasKidneyDisease: this.data.medicalHistory.hasKidneyDisease,
        familyDiabetes: this.data.medicalHistory.familyDiabetes,
        medications: this.data.medicalHistory.medications || [],
        diagnosisDate: this.data.healthInfo.diagnosisYear 
          ? new Date(this.data.healthInfo.diagnosisYear.toString(), 0, 1).toISOString()
          : '',
        riskLevel: this.data.healthInfo.riskLevel,
        physiologicalStatus: physiologicalStatus,
        activityLevel: activityLevel,
        // 添加用于确保这些特定字段被更新的标志
        shouldUpdateWeight: true,
        shouldUpdateBloodType: true,
        shouldUpdateActivityLevel: true,
        shouldUpdatePhysiologicalStatus: true,
        shouldUpdateMedicalHistory: true
      };
      
      // 准备个人资料数据
      const profileData = {
        _id: userId,
        userId: userId,
        nickname: this.data.userInfo.nickName || this.data.userInfo.nickname || '',
        email: this.data.userInfo.email || '',
        phoneNumber: this.data.userInfo.phoneNumber || '',
        // 复制重要的健康字段到个人资料数据，以确保这些数据也能同步更新
        height: height,
        weight: weight,
        bloodType: bloodType,
        physiologicalStatus: physiologicalStatus,
        activityLevel: activityLevel,
        waistline: waistline,
        bmi: bmi
      };
      
      console.log('发送健康档案数据:', JSON.stringify(healthProfileData, null, 2));
      console.log('发送个人资料数据:', JSON.stringify(profileData, null, 2));
      
      // 合并请求：将所有数据都发送到两个接口
      const directCombinedData = { ...healthProfileData, ...profileData };
      
      // 尝试使用直接API测试 - 使用合并的数据发送到两个接口
      try {
        console.log('[API测试] 开始直接API测试');
        
        // 直接发送合并数据到两个接口
        const directHealthResponse = await this.directApiTest('/users/health-profile', 'PUT', directCombinedData);
        console.log('[API测试] 健康档案直接API测试结果:', directHealthResponse);
        
        const directProfileResponse = await this.directApiTest('/users/profile', 'PUT', directCombinedData);
        console.log('[API测试] 个人资料直接API测试结果:', directProfileResponse);
      } catch (testError) {
        console.error('[API测试] 直接API测试失败:', testError);
      }
      
      // 更新健康档案
      const healthResponse = await api.updateHealthProfile(directCombinedData);
      console.log('健康档案更新结果:', healthResponse);
      
      // 更新个人资料
      const profileResponse = await api.updateUserProfile(directCombinedData);
      console.log('个人资料更新结果:', profileResponse);
      
      if (healthResponse.success && profileResponse.success) {
        // 更新全局数据
        app.globalData.userInfo = {
          ...app.globalData.userInfo,
          ...this.data.userInfo,
          weight: weight,
          bloodType: bloodType,
          physiologicalStatus: physiologicalStatus,
          activityLevel: activityLevel
        };
        
        // 保存到本地存储
        wx.setStorageSync('userInfo', app.globalData.userInfo);
        
        // 也保存完整用户资料到本地，以便其他API调用
        wx.setStorageSync('userProfile', {
          ...this.data.userInfo,
          ...directCombinedData
        });
        
        wx.hideLoading();
        wx.showToast({
          title: '保存成功',
          icon: 'success',
          duration: 2000,
          success: () => {
            // 清除保存提醒标记
            this.setData({ needSaveReminder: false });
            
            // 延迟返回上一页
            setTimeout(() => {
              console.log('准备返回上一页');
              // 使用navigateBack而不是navigateTo直接返回上一页
              wx.navigateBack();
            }, 1000);
          }
        });
      } else {
        wx.hideLoading();
        wx.showToast({
          title: '保存失败: ' + (healthResponse.message || profileResponse.message || '未知错误'),
          icon: 'none',
          duration: 2000
        });
      }
    } catch (error) {
      wx.hideLoading();
      console.error('保存用户信息失败:', error);
      wx.showToast({
        title: '保存失败: ' + (error.message || '未知错误'),
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 页面卸载时检查是否有未保存的修改
   */
  onUnload() {
    if (this.data.needSaveReminder) {
      // 有未保存的更改，可以考虑保存到本地缓存
      wx.setStorageSync('userInfoDraft', {
        userInfo: this.data.userInfo,
        healthInfo: this.data.healthInfo,
        medicalHistory: this.data.medicalHistory
      })
    }
  },

  /**
   * 获取糖尿病类型字符串
   * @returns {string} 糖尿病类型字符串
   */
  getDiabetesTypeString() {
    console.log('获取糖尿病类型字符串:', this.data.healthInfo.diabetesType);
    switch (this.data.healthInfo.diabetesType) {
      case 1: return '1型';
      case 2: return '2型';
      case 3: return '妊娠期';
      case 4: return '其他';
      default: return '无';
    }
  },

  /**
   * 获取生理状况字符串
   * @returns {string} 生理状况字符串
   */
  getPhysiologicalStatusString() {
    console.log('获取生理状况字符串:', this.data.physiologicalStatusIndex);
    switch (this.data.physiologicalStatusIndex) {
      case 1: return 'pregnant_early';
      case 2: return 'pregnant_mid';
      case 3: return 'pregnant_late';
      case 4: return 'breastfeeding';
      default: return 'normal';
    }
  },

  /**
   * 获取活动水平字符串
   * @returns {string} 活动水平字符串
   */
  getActivityLevelString() {
    console.log('获取活动水平字符串:', this.data.activityLevelIndex);
    switch (this.data.activityLevelIndex) {
      case 1: return 'moderate';
      case 2: return 'heavy';
      default: return 'light';
    }
  },
}) 